package com.spring;

import java.beans.Introspector;
import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 只有过程是大概一样的，但一些实现没有完全照抄
 * 这个类就一个构造方法，也是整个框架的入口
 *  1. 读取配置文件
 *  2. 扫描相关的类
 *  3. 初始化扫描到的类，并且将其放入到IOC容器之中
 *  4. 实现依赖注入
 *  5. 初始化
 *  6. 实现AOP
 *
 *  那么Spring到底是如何来创建一个Bean的呢，这个就是Bean创建的生命周期，大致过程如下
 *
 * 1.利用该类的构造方法来实例化得到一个对象（但是如何一个类中有多个构造方法，Spring则会进行选择，这个叫做推断构造方法）
 * 2.得到一个对象后，Spring会判断该对象中是否存在被@Autowired注解了的属性，把这些属性找出来并由Spring进行赋值（依赖注入）
 * 3.依赖注入后，Spring会判断该对象是否实现了BeanNameAware接口、BeanClassLoaderAware接口、BeanFactoryAware接口，
 * 如果实现了，就表示当前对象必须实现该接口中所定义的setBeanName()、setBeanClassLoader()、setBeanFactory()方法，
 * 那Spring就会调用这些方法并传入相应的参数（Aware回调）
 * 4.Aware回调后，Spring会判断该对象中是否存在某个方法被@PostConstruct注解了，如果存在，Spring会调用当前对象的此方法（初始化前）
 * 5.紧接着，Spring会判断该对象是否实现了InitializingBean接口，如果实现了，就表示当前对象必须实现该接口中的afterPropertiesSet()方法，
 * 那Spring就会调用当前对象中的afterPropertiesSet()方法（初始化）
 * 6.最后，Spring会判断当前对象需不需要进行AOP，如果不需要那么Bean就创建完了，如果需要进行AOP，则会进行动态代理并生成一个代理对象做为Bean（初始化后）
 *
 *
 * 通过最后一步，我们可以发现，当Spring根据UserService类来创建一个Bean时：
 *
 * 如果不用进行AOP，那么Bean就是UserService类的构造方法所得到的对象。
 * 如果需要进行AOP，那么Bean就是UserService的代理类所实例化得到的对象，而不是UserService本身所得到的对象。
 *
 *
 * Bean对象创建出来后：
 *
 * 如果当前Bean是单例Bean，那么会把该Bean对象存入一个Map<String, Object>，Map的key为beanName，value为Bean对象。
 * 这样下次getBean时就可以直接从Map中拿到对应的Bean对象了。（实际上，在Spring源码中，这个Map就是单例池）
 * 如果当前Bean是原型Bean，那么后续没有其他动作，不会存入一个Map，下次getBean时会再次执行上述创建过程，得到一个新的Bean对象。
 */
public class ZhuApplicationContext {
    private Class configClass;

    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<>();
    //单例池map
    private Map<String, Object> singletonObjects = new HashMap<>();
    private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();


    public ZhuApplicationContext(Class configClass) {
        this.configClass = configClass;
        //扫描写入beanDefinitionMap
        scan(configClass);
        //遍历beanDefinitionMap的所有值   map.entrySet()
        for (Map.Entry<String, BeanDefinition> entry : beanDefinitionMap.entrySet()) {
            String beanName = entry.getKey();
            BeanDefinition beanDefinition = entry.getValue();
            //把单例bean放入单例池中
            if (beanDefinition.getScope().equals("singleton")) {
                Object bean = createBean(beanName, beanDefinition);
                singletonObjects.put(beanName, bean);
            }
        }
    }





    public Object getBean(String beanName) {
        //如果map里没有这个bean,就抛出异常
        if (!beanDefinitionMap.containsKey(beanName)){
            throw new NullPointerException();
        }
      //根据beanName获取到BeanDefinition对象,判断是否是单例bean
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        //如果是单例bean,如果不是,则直接创建.
        if (beanDefinition.getScope().equals("singleton")){
            Object singletonBean = singletonObjects.get(beanName);
            if (singletonBean == null) {
                singletonBean = createBean(beanName, beanDefinition);
                singletonObjects.put(beanName, singletonBean);
            }
            return singletonBean;
        }else{
            // 原型
            Object prototypeBean = createBean(beanName, beanDefinition);
            return prototypeBean;
        }
    }


    /**
     * 扫描configClass定义的路径下的所有包,并存入beanDefinitionMap中
     * @param configClass
     */
    private void scan(Class configClass) {
        if (configClass.isAnnotationPresent(ComponentScan.class)) {
            ComponentScan componentScan = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
            String path = componentScan.value();//com.zhu.service
            path = path.replace(".", "/");//com/zhu/service
            ClassLoader classLoader = ZhuApplicationContext.class.getClassLoader();//获取类加载器
            URL resource = classLoader.getResource(path);
            File file = new File(resource.getFile());
            if (file.isDirectory()) {
                for (File f : file.listFiles()) {
                    String absolutePath = f.getAbsolutePath();//E:\code\spring-hand\target\classes\com\zhu\service\OrderService.class
                    absolutePath = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
                    absolutePath = absolutePath.replace("\\", ".");//com.zhu.service.OrderService
                    try {
                        Class<?> clazz = classLoader.loadClass(absolutePath);
                        //判断这个类有没有Component注解
                        if (clazz.isAnnotationPresent(Component.class)) {
                            //判断这个类有没有实现BeanPostProcessor接口
                            if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
                                BeanPostProcessor instance = (BeanPostProcessor) clazz.getConstructor().newInstance();
                                beanPostProcessorList.add(instance);
                            }
                            //获取component的名字,然后把它放入map中作为key
                            Component componentAnnotation = clazz.getAnnotation(Component.class);
                            String beanName = componentAnnotation.value();
                            //如果获取的名字是空,则使用jdk的一个方法生成个名字,把类名首字母小写
                            if ("".equals(beanName)) {
                                beanName = Introspector.decapitalize(clazz.getSimpleName());
                            }
                            BeanDefinition beanDefinition = new BeanDefinition();
                            beanDefinition.setType(clazz);

                            //判断有没有Scope注解,如果有,根据注解设置BeanDefinition的Scope值,否则默认为单例bean
                            if (clazz.isAnnotationPresent(Scope.class)) {
                                Scope scopeAnnotation = clazz.getAnnotation(Scope.class);
                                String value = scopeAnnotation.value();
                                beanDefinition.setScope(value);
                            } else {
                                beanDefinition.setScope("singleton");
                            }
                            beanDefinitionMap.put(beanName, beanDefinition);


                        }

                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        throw new RuntimeException(e);
                    } catch (InstantiationException e) {
                        throw new RuntimeException(e);
                    } catch (IllegalAccessException e) {
                        throw new RuntimeException(e);
                    } catch (NoSuchMethodException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }
    }
    /**
     * 创建bean
     * @param beanName
     * @param beanDefinition
     * @return
     */
    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        Class clazz=beanDefinition.getType();
        Object instance=null;
        try {
            //调用类的无参构造方法
            instance=clazz.getConstructor().newInstance();
            //依赖注入
            for (Field field : clazz.getDeclaredFields()) {
                if (field.isAnnotationPresent(Autowired.class)) {

                    field.setAccessible(true);

                    field.set(instance, getBean(field.getName()));
                }
            }
            //如果有实现BeanNameAware接口，则对该bean的beanName属性进行赋值
            if (instance instanceof BeanNameAware) {
                ((BeanNameAware)instance).setBeanName(beanName);
            }

            //初始化前
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessBeforeInitialization(instance, beanName);
            }
            //初始化
            if (instance instanceof InitializingBean) {
                ((InitializingBean)instance).afterPropertiesSet();
            }
            //初始化后
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessAfterInitialization(instance, beanName);
            }
        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
        return  instance;

    }
}
